/*
 * Created on 21-Jun-2004
 * Created by Paul Gardner
 * Copyright (C) Azureus Software, Inc, All Rights Reserved.
 *
 * This program is free software; you can redistribute it and/or
 * modify it under the terms of the GNU General Public License
 * as published by the Free Software Foundation; either version 2
 * of the License, or (at your option) any later version.
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 *
 */

package org.gudy.azureus2.pluginsimpl.remote.tracker;

import org.gudy.azureus2.plugins.torrent.Torrent;
import org.gudy.azureus2.plugins.tracker.TrackerException;
import org.gudy.azureus2.plugins.tracker.TrackerPeer;
import org.gudy.azureus2.plugins.tracker.TrackerTorrent;
import org.gudy.azureus2.plugins.tracker.TrackerTorrentListener;
import org.gudy.azureus2.plugins.tracker.TrackerTorrentRemovalVetoException;
import org.gudy.azureus2.plugins.tracker.TrackerTorrentWillBeRemovedListener;
import org.gudy.azureus2.pluginsimpl.remote.RPException;
import org.gudy.azureus2.pluginsimpl.remote.RPObject;
import org.gudy.azureus2.pluginsimpl.remote.RPReply;
import org.gudy.azureus2.pluginsimpl.remote.RPRequest;
import org.gudy.azureus2.pluginsimpl.remote.RPRequestDispatcher;
import org.gudy.azureus2.pluginsimpl.remote.torrent.RPTorrent;

/**
 * @author parg
 * 
 */

public class RPTrackerTorrent extends RPObject implements TrackerTorrent {
    protected transient TrackerTorrent delegate;

    // don't change the names of these, they appear in XML serialisation

    public RPTorrent torrent;

    public int status;
    public long total_uploaded;
    public long total_downloaded;
    public long average_uploaded;
    public long average_downloaded;
    public long total_left;
    public long completed_count;
    public long total_bytes_in;
    public long average_bytes_in;
    public long total_bytes_out;
    public long average_bytes_out;
    public long scrape_count;
    public long average_scrape_count;
    public long announce_count;
    public long average_announce_count;
    public int seed_count;
    public int leecher_count;
    public int bad_NAT_count;

    public static RPTrackerTorrent create(TrackerTorrent _delegate) {
        RPTrackerTorrent res = (RPTrackerTorrent) _lookupLocal(_delegate);

        if (res == null) {

            res = new RPTrackerTorrent(_delegate);
        }

        return (res);
    }

    protected RPTrackerTorrent(TrackerTorrent _delegate) {
        super(_delegate);

        if (delegate.getTorrent() != null) {

            torrent = (RPTorrent) _lookupLocal(delegate.getTorrent());

            if (torrent == null) {

                torrent = RPTorrent.create(delegate.getTorrent());
            }
        }
    }

    protected void _setDelegate(Object _delegate) {
        delegate = (TrackerTorrent) _delegate;

        status = delegate.getStatus();
        total_uploaded = delegate.getTotalUploaded();
        total_downloaded = delegate.getTotalDownloaded();
        average_uploaded = delegate.getAverageUploaded();
        average_downloaded = delegate.getAverageDownloaded();
        total_left = delegate.getTotalLeft();
        completed_count = delegate.getCompletedCount();
        total_bytes_in = delegate.getTotalBytesIn();
        average_bytes_in = delegate.getAverageBytesIn();
        total_bytes_out = delegate.getTotalBytesOut();
        average_bytes_out = delegate.getAverageBytesOut();
        scrape_count = delegate.getScrapeCount();
        average_scrape_count = delegate.getAverageScrapeCount();
        announce_count = delegate.getAnnounceCount();
        average_announce_count = delegate.getAverageAnnounceCount();
        seed_count = delegate.getSeedCount();
        leecher_count = delegate.getLeecherCount();
        bad_NAT_count = delegate.getBadNATCount();
    }

    public Object _setLocal()

    throws RPException {
        Object res = _fixupLocal();

        if (torrent != null) {

            torrent._setLocal();
        }

        return (res);
    }

    public void _setRemote(RPRequestDispatcher dispatcher) {
        super._setRemote(dispatcher);

        if (torrent != null) {

            torrent._setRemote(dispatcher);
        }
    }

    public RPReply _process(RPRequest request) {
        String method = request.getMethod();
        // Object[] params = request.getParams();

        throw (new RPException("Unknown method: " + method));
    }

    // ***************************************************************************8

    public void start()

    throws TrackerException {
        notSupported();
    }

    public void stop()

    throws TrackerException {
        notSupported();
    }

    public void remove()

    throws TrackerTorrentRemovalVetoException {
        notSupported();

    }

    public boolean canBeRemoved()

    throws TrackerTorrentRemovalVetoException {
        notSupported();

        return (false);
    }

    public Torrent getTorrent() {
        return (torrent);
    }

    public TrackerPeer[] getPeers() {
        notSupported();

        return (null);
    }

    public int getStatus() {
        return (status);
    }

    public long getTotalUploaded() {
        return (total_uploaded);
    }

    public long getTotalDownloaded() {
        return (total_downloaded);
    }

    public long getAverageUploaded() {
        return (average_uploaded);
    }

    public long getAverageDownloaded() {
        return (average_downloaded);
    }

    public long getTotalLeft() {
        return (total_left);
    }

    public long getCompletedCount() {
        return (completed_count);
    }

    public long getTotalBytesIn() {
        return (total_bytes_in);
    }

    public long getAverageBytesIn() {
        return (average_bytes_in);
    }

    public long getTotalBytesOut() {
        return (total_bytes_out);
    }

    public long getAverageBytesOut() {
        return (average_bytes_out);
    }

    public long getScrapeCount() {
        return (scrape_count);
    }

    public long getAverageScrapeCount() {
        return (average_scrape_count);
    }

    public long getAnnounceCount() {
        return (announce_count);
    }

    public long getAverageAnnounceCount() {
        return (average_announce_count);
    }

    public int getSeedCount() {
        return (seed_count);
    }

    public int getLeecherCount() {
        return (leecher_count);
    }

    public int getBadNATCount() {
        return (bad_NAT_count);
    }

    public void disableReplyCaching() {
        notSupported();
    }

    public boolean isPassive() {
        notSupported();

        return (false);
    }

    public long getDateAdded() {
        notSupported();

        return (0);
    }

    public void addListener(TrackerTorrentListener listener) {
        notSupported();
    }

    public void removeListener(TrackerTorrentListener listener) {
        notSupported();
    }

    public void addRemovalListener(TrackerTorrentWillBeRemovedListener listener) {
        notSupported();
    }

    public void removeRemovalListener(TrackerTorrentWillBeRemovedListener listener) {
        notSupported();
    }
}
